package com.oraycn.esbasic.objectManagement;

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue; 

/**
 * 实现一个固定长度的集合队列
 */
public class LimitQueue<T> implements Queue<T> {

    /**
     * 队列长度，实例化类的时候指定
     */
    private int limit;

    Queue<T> queue = new LinkedList<T>();

    public LimitQueue(int limit){
        this.limit = limit;
    }

    /**
     * 获取队列长度
     */
    public int getLimit()
    {
        return this.limit;
    }

    /**
     * 获取队列
     */
    public Queue<T> getQueue()
    {
        return this.queue;
    }

    @Override
    public int size() {
        return queue.size();
    }

    @Override
    public boolean isEmpty() {
        return queue.size()==0;
    }

    @Override
    public boolean contains(Object o) {
        return queue.contains(o);
    }

    @Override
    public Iterator<T> iterator() {
        return queue.iterator();
    }

    @Override
    public Object[] toArray() {
        return queue.toArray();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return queue.toArray(a);
    }

    @Override
    public boolean add(T t) {
        return queue.add(t);
    }

    @Override
    public boolean remove(Object o) {
        return queue.remove(o);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        return queue.addAll(c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return queue.removeAll(c);
    }


    /**
     * A.retainAll(B)
     * 这个方法改变了集合A中的元素，将存在于集合A中但不存在于集合B中的元素移除。
     *
     * 如果集合A的大小发生了改变，返回true，即使两个集合完全没有交集，也会返回true。
     * 如果集合A的大小没有发生改变，返回false，即使两个集合完全相同，也会返回false。
     */
    @Override
    public boolean retainAll(Collection<?> c) {
        return queue.retainAll(c);
    }

    @Override
    public void clear() {
        queue.clear();
    }

    /**
    * 入队 若队列已满，先移除最早进来的元素，再入队
    * */
    @Override
    public boolean offer(T t) {
        if(queue.size()>=this.limit)
        {
            queue.poll();
        }
        return queue.offer(t);
    }

    /**
     * 移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常
     */
    @Override
    public T remove() {
        return queue.remove();
    }

    /**
     * 出队  移除并返问队列头部的元素    如果队列为空，则返回null
     */
    @Override
    public T poll() {
        return queue.poll();
    }

    /**
     * 返回队列头部的元素   如果队列为空，则抛出一个NoSuchElementException异常
     */
    @Override
    public T element() {
        return queue.element();
    }

    /**
     * 返回队列头部的元素   如果队列为空，则返回null
     */
    @Override
    public T peek() {
        return queue.peek();
    }
}